home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Storage.C < prev    next >
C/C++ Source or Header  |  1992-08-19  |  10KB  |  471 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Storage.h"
  6.  
  7. #include "CLib.h"
  8. #include "String.h"
  9. #include "Error.h"
  10. #include "Object.h"
  11. #include "ObjectTable.h"
  12. #include "Math.h"
  13.  
  14. #define MEM_MAGIC ((char)0xAB)
  15. #define MEM_STAT
  16. //#define MEM_CHECKOBJECTPOINTERS
  17.  
  18. #ifdef MEM_CHECKOBJECTPOINTERS
  19. #   define CheckObjPtr(name, p) ObjectTable::CheckPtrAndWarn(name, p);
  20. #else
  21. #   define CheckObjPtr(name, p) p
  22. #endif
  23.  
  24. const int cMemPoolSize  =   100,
  25.       cObjMaxSize   =   1024;       
  26.  
  27. u_long Storage_lastobj, Storage_lastobjend;
  28. bool Storage_proto;
  29.  
  30. static bool died;
  31. static size_t maxA;
  32. static FreeHookFun storageFreeHook;
  33. static void *storageFreeHookData;
  34.  
  35. //---- Pool for a specific size ------------------------------------------------
  36.  
  37. struct FreeNode {
  38.     class FreeNode *next;
  39. };
  40.  
  41. class Chunk {
  42. public:
  43.     struct Chunk *next;
  44.     char *storage;
  45. public:
  46.     Chunk(Chunk *n, size_t size)
  47.     { next= n; storage= new char[size]; }
  48.     ~Chunk()
  49.     { SafeDelete(storage); }
  50. };
  51.  
  52. class MemPool {
  53. public:
  54. friend class Storage;
  55.     struct Chunk *chunks;
  56.     struct FreeNode *freeList;
  57.     int lastIndex, chunkSize, allocated, recycled, freed;
  58.     size_t objSize;
  59. public:
  60.     MemPool(size_t objSize);
  61.     ~MemPool();
  62.     void *Alloc();
  63.     void Free(void *);
  64.     int nchunks();
  65. };
  66.  
  67. static MemPool *pools[cObjMaxSize];
  68.  
  69. #ifdef MEM_STAT
  70.  
  71.     static bool gMemStatistics;
  72.     static int ASizes[cObjMaxSize];
  73.     static int FSizes[cObjMaxSize];
  74.     static int totalA, totalF;
  75.     static void *ttt[1000];
  76.     static int tt, mem_size= -1, mem_ix= -1;
  77.     
  78.     void EnterStat(size_t size, void *p)
  79.     {
  80.     if (gMemStatistics && size == mem_size) {
  81.         if (tt == mem_ix)
  82.         CLib::Abort();
  83.         ttt[tt++]= p;
  84.     }
  85.     maxA= Math::Max(maxA, size);
  86.     if (size >= cObjMaxSize)
  87.         ASizes[cObjMaxSize-1]++;
  88.     else
  89.         ASizes[size]++;
  90.     totalA+= size;
  91.     }
  92.     
  93.     void RemoveStat(size_t size, void *vp)
  94.     {
  95.     if (gMemStatistics && size == mem_size) {
  96.         for (int i= 0; i < tt; i++)
  97.         if (ttt[i] == vp) {
  98.             ttt[i]= 0;
  99.             break;
  100.         }
  101.     }
  102.     if (size >= cObjMaxSize)
  103.         FSizes[cObjMaxSize-1]++;
  104.     else
  105.         FSizes[size]++;
  106.     totalF+= size;
  107.     }
  108.     
  109. #else
  110.  
  111. #   define EnterStat(s, p) maxA= Math::Max(maxA, s);
  112. #   define RemoveStat(s, p)
  113.  
  114. #endif
  115.  
  116. static bool FreeFromPool(void *vp)
  117. {
  118.     register int i;
  119.     register Chunk *p;
  120.     register MemPool *mp;
  121.  
  122.     for (i= 0; i < cObjMaxSize; i++) {
  123.     if (mp= pools[i]) {
  124.         for (p= mp->chunks; p; p= p->next) {
  125.         if (vp >= (void*)p->storage
  126.                     && vp < (void*)(p->storage + mp->chunkSize)) {
  127.             mp->Free(vp);
  128.             return TRUE;
  129.         }
  130.         }
  131.     }
  132.     }
  133.     return FALSE;
  134. }
  135.  
  136. /*
  137. inline size_t storage_size(char *ptr)
  138. { 
  139.     return ((int*)ptr)[-1];
  140. }
  141. */
  142.  
  143. #define storage_size(ptr) ((size_t)(((int*)ptr)[-1]))
  144.  
  145. //---- Pool for a specific size ------------------------------------------------
  146.  
  147. MemPool::MemPool(size_t osize)
  148. {
  149.     objSize= osize;
  150.     chunkSize= cMemPoolSize * objSize;
  151.     chunks= 0;
  152.     lastIndex= cMemPoolSize; // force allocation of a new chunk
  153.     freeList= 0;
  154.     allocated= recycled= freed= 0;
  155. }
  156.  
  157. MemPool::~MemPool()
  158. {
  159.     Chunk *p, *lp;
  160.  
  161.     for (p= chunks; p; p= lp) {
  162.     lp= p->next;
  163.     delete p;
  164.     }
  165. }
  166.  
  167. int MemPool::nchunks()
  168. {
  169.     int n;
  170.     Chunk *p;
  171.     
  172.     for (n= 0, p= chunks; p; p= p->next, n++)
  173.     ;
  174.     return n;
  175. }
  176.  
  177. void *MemPool::Alloc()
  178. {
  179.     allocated++;
  180.     if (freeList) {
  181.     recycled++;
  182.     FreeNode *tmp= freeList;
  183.     freeList= freeList->next;
  184.     return (void*)tmp;
  185.     }
  186.     if (lastIndex >= cMemPoolSize) { // need new chunk
  187.     chunks= new Chunk(chunks, chunkSize);
  188.     lastIndex= 0;
  189.     }
  190.     return (void*) &chunks->storage[lastIndex++ * objSize];
  191. }
  192.  
  193. void MemPool::Free(void *op)
  194. {
  195.     if (storageFreeHook)
  196.     storageFreeHook(storageFreeHookData, op, objSize);
  197.  
  198.     for (Chunk *p= chunks; p; p= p->next) {
  199.     if (op >= (void*)p->storage && op <  (void*)(p->storage + chunkSize)) {
  200.         memset(op, 0, objSize);
  201.         FreeNode *fn= (FreeNode*)op;
  202.         fn->next= freeList;
  203.         freeList= fn;
  204.         freed++;
  205.         return;
  206.     }
  207.     }
  208.     fprintf(stderr, "Fatal in MemPool::Free: object to delete not found in pool %d\n", objSize);
  209.     fflush(stderr);
  210.     CLib::Abort();
  211. }
  212.  
  213. //---- Storage -----------------------------------------------------------------
  214.  
  215. void* operator new(size_t size)
  216. {
  217.     register int *sp;
  218.  
  219.     if (size < 0) {
  220.     fprintf(stderr, "Fatal in operator new: size < 0\n");
  221.     fflush(stderr);
  222.     CLib::Abort();
  223.     }
  224. #ifdef MEM_MAGIC
  225.     sp= (int*) CLib::CAlloc(size + sizeof(int) + sizeof(char), sizeof(char));
  226. #else
  227.     sp= (int*) CLib::CAlloc(size + sizeof(int), sizeof(char));
  228. #endif
  229.     if (sp == 0) {
  230.     fprintf(stderr, "Fatal in operator new: storage exhausted\n");
  231.     fflush(stderr);
  232.     CLib::Abort();
  233.     }
  234.     sp[0]= size;
  235. #ifdef MEM_MAGIC
  236.     *((char*)sp+size+sizeof(int))= MEM_MAGIC;
  237. #endif
  238.     EnterStat(size, &sp[1]);
  239.     return CheckObjPtr("new", &sp[1]);
  240. }
  241.  
  242. void operator delete(void* ptr)
  243. {
  244.     Storage_lastobj= Storage_lastobjend= 0;
  245.     Storage_proto= FALSE;
  246.     if (ptr) {
  247.     (void) CheckObjPtr("free", ptr);
  248.     if (!died && FreeFromPool(ptr))
  249.         return;
  250.     int size= storage_size((char*)ptr);
  251.     if (size < 0 || size > maxA) {
  252.         fprintf(stderr, "Fatal in operator delete: unreasonable size (%d)\n", size);
  253.         fflush(stderr);
  254.         CLib::Abort();
  255.     }
  256.     RemoveStat(size, ptr);
  257.     if (storageFreeHook) 
  258.         storageFreeHook(storageFreeHookData, ptr, size);
  259.     ptr= (char*)ptr - sizeof(int);
  260.     size+=sizeof(int);
  261. #ifdef MEM_MAGIC
  262.     if (*((char*)ptr+size) != MEM_MAGIC) {
  263.         fprintf(stderr, "Fatal in operator delete: storage area overwritten\n");
  264.         fflush(stderr);
  265.         CLib::Abort();
  266.     }
  267.     size+= sizeof(char);
  268. #endif
  269.     memset(ptr, 0, size);
  270.     CLib::ErrNo= 0;
  271.     CLib::Free((char*) ptr);
  272.     if (CLib::ErrNo != 0) {
  273.         perror("operator delete");
  274.         CLib::Abort();
  275.     }
  276.     }
  277. }
  278.  
  279. void *Realloc(void *vp, size_t size)
  280. {
  281.     if (vp == 0)
  282.     return new char[size];
  283.     
  284.     int oldsize= storage_size((char*)vp);
  285.     if (size > oldsize) {
  286.     int *sp, sz= size;
  287.     char *ptr= (char*)vp, *cp;
  288.     
  289.     RemoveStat(oldsize, vp);
  290.     
  291. #ifdef MEM_MAGIC
  292.     sz+= sizeof(char);
  293. #endif
  294.     sp= (int*) CLib::ReAlloc((char*) (ptr - sizeof(int)), sz+sizeof(int));
  295.     cp= (char*) &sp[1];
  296.     EnterStat(size, &sp[1]);
  297.     
  298. #ifdef MEM_MAGIC
  299.     if (cp[oldsize] != MEM_MAGIC) {
  300.         fprintf(stderr, "Fatal in Realloc: storage area overwritten\n");
  301.         fflush(stderr);
  302.         CLib::Abort();
  303.     }
  304.     *((char*)sp+size+sizeof(int))= MEM_MAGIC;
  305. #endif
  306.     memset(&cp[oldsize], 0, size-oldsize);
  307.     sp[0]= size;
  308.     return CheckObjPtr("Realloc", cp);
  309.     }
  310.     return vp;
  311. }
  312.  
  313. void *Storage::Alloc(size_t sz)
  314. {
  315.     return new char[sz];
  316. }
  317.  
  318. void *Storage::Alloc(size_t sz, const char*, int)
  319. {
  320.     return new char[sz];
  321. }
  322.  
  323. void Storage::Free(void *vp)
  324. {
  325.     delete vp;
  326. }
  327.  
  328. void *Storage::ChunkAlloc(size_t sz)
  329. {
  330.     if (died || sz >= cObjMaxSize)
  331.     return (void*) new char[sz];
  332.     MemPool *mp= pools[sz];
  333.     if (mp == 0)
  334.     mp= pools[sz]= new MemPool(sz);
  335.     return CheckObjPtr("Storage::ChunkAlloc", mp->Alloc());
  336. }
  337.  
  338. void Storage::ChunkFree(void *vp)
  339. {
  340.     register int i;
  341.     register Chunk *p;
  342.     register MemPool *mp;
  343.  
  344.     for (i= 0; i < cObjMaxSize; i++) {
  345.     if (mp= pools[i]) {
  346.         for (p= mp->chunks; p; p= p->next) {
  347.         if (vp >= (void*)p->storage
  348.                     && vp < (void*)(p->storage + mp->chunkSize)) {
  349.             mp->Free(vp);
  350.             return;
  351.         }
  352.         }
  353.     }
  354.     }
  355. }
  356.  
  357. void *Storage::ObjectChunkAlloc(size_t sz)
  358. {
  359.     if (died || sz >= cObjMaxSize)
  360.     return (void*) new char[sz];
  361.     MemPool *mp= pools[sz];
  362.     if (mp == 0) 
  363.     mp= pools[sz]= new MemPool(sz);
  364.     return CheckObjPtr("Storage::ObjectChunkAlloc", mp->Alloc());
  365. }
  366.  
  367. void Storage::ObjectChunkFree(void *vp)
  368. {
  369.     delete vp;
  370. }
  371.  
  372. void *Storage::ObjectAlloc(size_t sz)
  373. {
  374.     Storage_proto= FALSE;
  375.     Storage_lastobj= (u_long) new char[sz];
  376.     Storage_lastobjend= Storage_lastobj + sz;
  377.     return (void*) Storage_lastobj;
  378. }
  379.  
  380. void *Storage::ObjectAlloc(size_t sz, const char*, int)
  381. {
  382.     Storage_proto= FALSE;
  383.     Storage_lastobj= (u_long) new char[sz];
  384.     Storage_lastobjend= Storage_lastobj + sz;
  385.     return (void*) Storage_lastobj;
  386. }
  387.  
  388. void Storage::ObjectFree(void *vp)
  389. {
  390.     delete vp;
  391. }
  392.  
  393. void *Storage::ReAlloc(void *vp, size_t sz)
  394. {
  395.     return ::Realloc(vp, sz);
  396. }
  397.  
  398. void Storage::SetFreeHook(FreeHookFun fh, void *data)
  399. {
  400.     storageFreeHook= fh;
  401.     storageFreeHookData= data;
  402. }
  403.  
  404. void Storage::Statistics()
  405. {
  406. #ifdef MEM_STAT
  407.     MemPool *fsp;
  408.     
  409.     if (!gMemStatistics)
  410.     return;
  411.     
  412.     if (totalA == totalF) {
  413.     fprintf(stderr, "no garbage left (total: %d)\n", totalA);
  414.     return;
  415.     }
  416.     
  417.     fprintf(stderr, "\n");
  418.     fprintf(stderr, "Mem statistics\n");
  419.     fprintf(stderr, "%7s%7s%7s%7s%7s%7s%7s%7s",
  420.     "size", "alloc", "free", "diff", "alloc", "recycl", "freed", "chunks\n");
  421.     fprintf(stderr, "=======================================================\n");
  422.     
  423.  
  424.     for (int i= 0; i < cObjMaxSize; i++) {
  425.     fsp= pools[i];
  426.     if (ASizes[i] != FSizes[i] || fsp)
  427.         fprintf(stderr, "%7d%7d%7d%7d", i, ASizes[i], FSizes[i],
  428.                             ASizes[i]-FSizes[i]);
  429.     if (fsp)
  430.         fprintf(stderr, "%7d%7d%7d%7d", fsp->allocated, 
  431.                     fsp->recycled, fsp->freed, fsp->nchunks());
  432.     if (ASizes[i] != FSizes[i] || fsp)
  433.         fprintf(stderr, "\n");
  434.     }
  435.  
  436.     if (totalA != totalF) {
  437.     fprintf(stderr, "-------------------------------------------------------\n");
  438.     fprintf(stderr, "total: %7d%7d%7d\n", totalA, totalF, totalA-totalF);
  439.     }
  440.  
  441.     if (mem_size != -1) {
  442.     fprintf(stderr, "-------------------------------------------------------\n");
  443.     for (i= 0; i < tt; i++)
  444.         if (ttt[i])
  445.         fprintf(stderr, "block %d of size %d not freed\n", i, mem_size);
  446.     }
  447.     fprintf(stderr, "=======================================================\n");
  448.     fprintf(stderr, "\n");
  449.     fflush(stderr);
  450. #endif
  451. }
  452.  
  453. void Storage::EnableStatistics(int size, int ix)
  454. {
  455. #ifdef MEM_STAT
  456.     mem_size= size;
  457.     mem_ix= ix;
  458.     gMemStatistics= TRUE;
  459. #endif
  460. }
  461.  
  462. void Storage::FreeAll()
  463. {
  464.     died= TRUE;
  465.     for (int i= 0; i < cObjMaxSize; i++)
  466.     SafeDelete(pools[i]);
  467.  
  468.     Statistics();
  469. }
  470.  
  471.